#ifndef BASEMODEL_H
#define BASEMODEL_H
#include"sqlite/singledb.h"
#include<sqlite/sqlite3.h>
#include"data/user.h"
#include"data/video.h"
#include"data/logadduser.h"

#include <QScopedPointer>
#include<QList>

//class Any
//{
//public:
//    // 默认构造函数
//    Any() : base(nullptr) {}

//    // 析构函数，手动释放内存
//    ~Any()
//    {
//        qDebug() << "Any destructor called. Base type: ";
//        if(base!=nullptr)
//        delete base;

//    }

//    // 拷贝构造函数，实现深拷贝
//    Any(const Any& other) : base(nullptr)
//    {
//        if (other.base)
//        {
//            base = other.base->clone();
//        }
//    }

//    // 拷贝赋值运算符，实现深拷贝
//    Any& operator=(const Any& other)
//    {
//        if (this != &other)
//        {
//            // 释放当前对象的内存
//            delete base;
//            base = nullptr;

//            if (other.base)
//            {
//                base = other.base->clone();
//            }
//        }
//        return *this;
//    }

//    // 移动构造函数
//    Any(Any&& other) noexcept : base(other.base)
//    {
//        other.base = nullptr;
//    }

//    // 移动赋值运算符
//    Any& operator=(Any&& other) noexcept
//    {
//        if (this != &other)
//        {
//            // 释放当前对象的内存
//            delete base;
//            base = other.base;
//            other.base = nullptr;
//        }
//        return *this;
//    }

//    // 模板构造函数，用于存储任意类型的数据
//    template <typename T>
//    Any(T data) : base(new Derive<T>(data))
//    {}

//    // 模板转换函数，用于将存储的数据转换回原始类型
//    template <typename T>
//    T cast_()
//    {
//        Derive<T>* pd = dynamic_cast<Derive<T>*>(base);
//        if (pd == nullptr)
//        {
//            throw std::runtime_error("type is unmatch!");
//        }
//        return pd->data_;
//    }

//private:
//    // 基类类型
//    class Base
//    {
//    public:
//        virtual ~Base() = default;
//        // 纯虚函数，用于实现深拷贝
//        virtual Base* clone() const = 0;
//    };

//    // 派生类类型
//    template <typename T>
//    class Derive : public Base
//    {
//    public:
//        Derive(T data) : data_(data) {}
//        T data_;

//        // 实现 clone 方法，用于创建一个新的 Derive 对象
//        Base* clone() const override
//        {
//            return new Derive<T>(data_);
//        }
//    };

//    // 定义一个基类的指针
//   Base*base;
//};



class Any
{
public:
    Any() : base_(nullptr) {}
    ~Any() { delete base_; }

    Any(const Any& other) : base_(nullptr)
    {
        if (other.base_)
        {
            base_ = other.base_->clone();
        }
    }

    Any& operator=(const Any& other)
    {
        if (this != &other)
        {
            delete base_;
            base_ = other.base_ ? other.base_->clone() : nullptr;
        }
        return *this;
    }

    Any(Any&& other) noexcept : base_(other.base_)
    {
        other.base_ = nullptr;
    }

    Any& operator=(Any&& other) noexcept
    {
        if (this != &other)
        {
            delete base_;
            base_ = other.base_;
            other.base_ = nullptr;
        }
        return *this;
    }

    template <typename T>
    Any(T data) : base_(new Derive<T>(data)) {}//父类指针指向子类，同时data传递给子类

    template <typename T>
    T cast_()//为了获取保存参数的函数
    {
        Derive<T>* pd = dynamic_cast<Derive<T>*>(base_);
        if (pd == nullptr)
        {
            throw std::runtime_error("type is unmatch!");
        }
        return pd->data_;
    }

private:
    class Base
    {
    public:
        virtual ~Base() = default;
        virtual Base* clone() const = 0;
    };

    template <typename T>
    class Derive : public Base
    {
    public:
        Derive(T data) : data_(data) {}
        T data_;

        Base* clone() const override
        {
            return new Derive<T>(data_);
        }
    };

    Base* base_;
};
















class BaseModel
{
public:
    BaseModel();
    virtual ~BaseModel();

    virtual void insert(char *sql);
    virtual bool selectIsEmpty(char *sql);
    virtual User*getUserInfo(char *sql);
    virtual int selectUserId(char *sql);

    virtual QList<Video*> getVideoInfo(char *sql);
    virtual void insetVideoInfo(char *sql);




    virtual Any sqlInstruct(char *sql);//万能返回值，测试版本
    virtual Any sqlSelect(char *sql);



protected:
    SingleDB*db;
    sqlite3*psqlite3;


};

#endif // BASEMODEL_H
